…(D5 C4 groundwork)

FOUND WHILE SCOPING C4, and the reason this is a separate commit: four of the
eleven minute factors publish a scarcity / neutralization disclosure as an ADDED
report section, and three of them build it from a per-symbol DAY-LEVEL frame the
factor's compute function emits through its diagnostics_out sink. The old eval
runners had that frame because they ran the compute themselves. The unified runner
will not: values come from the D3 store through the D4/D4b materializer, and the
store persists VALUES ONLY. The day counts are not in it and cannot be recovered
from it.

That left exactly two fates for the disclosure — recompute it, or drop it. Dropping
a disclosure because the plumbing changed is the silent degradation this project
forbids, so the channel exists and its cost is stated wherever it is paid:

* MinuteStreamBinding gains an OPTIONAL per_symbol_diagnostics callable, kept
  SEPARATE from per_symbol on purpose — per_symbol is the value path D4b verified
  cell for cell, and a diagnostics request must not be able to change it. Asking
  re-runs the per-symbol math on bars already in memory: no extra I/O, no value
  effect. Bound for the three factors that publish a frame; the others answer
  has_minute_diagnostics() == False and return an EMPTY frame, which a caller must
  never read as "no attrition" (hence the separate, explicit predicate).
* materialize_range(..., diagnostics=sink) — default None is the D4b path byte for
  byte. The sink is EMIT-WINDOW scoped, so the denominator keeps the meaning it has
  in the frozen artifacts ("the days this run scored"), not "the days that were
  loaded"; for a pooled factor only the TERMINAL saturation load is observed, since
  the expansion steps are the search, not the computation. A daily factor plus a
  sink is a readable error rather than an empty sink.
* service.panel(..., diagnostics=sink) materializes the WHOLE requested range even
  on a full store hit, and refuses a shared sink for several factors (the frames
  carry no factor label, so a summarizer would silently reduce the mixture).

COST, stated rather than buried: three of eleven factors can never be served from a
warm store when their disclosure is wanted. That is a permanent charge the D5 plan
did not price, and it is the honest half of the trade above.

Mutation evidence (run, not claimed; each mutation asserted to hit its target):
* _sink_diagnostics returns an empty frame -> the VACUITY pre-assertion in the
  values-unchanged test FAILS (rc=1) instead of the equality passing for the wrong
  reason — the sink-stayed-empty shape is what makes such a test unfailable;
* drop the emit-window slice -> the scoping test FAILS with 576 loaded days;
* remove the sink-forces-refill branch -> the warm-store test FAILS on calls == 0.

Gates: pytest 2210 passed / ruff clean / 31 configs / phase0 ic 0.9600 annual 0.8408
unchanged / exec baseline --verify 77/77 / frozen panel mtimes untouched.

…ers that omit it

RECORDING MY OWN DEFECT, one commit old. 6046bbe defaulted EvalConfig.view /
return_basis to decision / exec_to_exec — the pairing the design is converging on,
and the wrong default for the code that exists today.

Each of the eleven live runners builds ONE EvalConfig (_build_eval_config) and hands
the SAME object to its close_to_close reports AND, through qt.exec_basis_eval, to its
exec ones. With the flattering default, every close artifact would have declared a
basis it was not scored on — the describe-the-check drift of #76/#78/#82, introduced
by the very field added to prevent it, in the same commit that added it. Nothing had
re-run yet, so no artifact carries the false label; the fix is before the fact.

A default's only job is to be TRUE for the callers that omit the field. Those callers
are on the close basis, so the default is close / close_to_close, and the exec path
states its identity EXPLICITLY — mirroring what qt.exec_basis_eval already does one
line earlier for the SPEC (intraday_spec_variant). When the close runners retire in
C6, flipping the default is a one-line change with no false statement left behind.

Pinned: a test asserts the default IS the legacy pairing and says why, and a
structural test asserts qt.exec_basis_eval restates the identity rather than
inheriting the caller's. The identity phrase test now covers both pairings, so the
author-once helper cannot be right for one and wrong for the other.

…corr as the one exception

FOUND BY MEASURING BEFORE COMMITTING TO THE MULTI-HOUR C5 RUN. qt/panel_leg_probe.py
compares the D4/D4b materializer's values on the real evaluation plane against the
D1 frozen panel — the fourth leg's comparison, taken as a probe first (the D5a
discipline that stopped D5 being started blind). The expectation was a small,
front-loaded warm-up difference. jump_amount_corr_20 came back with 1,155,500 of
1,158,382 both-finite cells differing, 931,394 of them AFTER year one where warm-up
cannot be the explanation, max relative difference 1.99 on a correlation bounded in
[-1, 1].

CHASED RATHER THAN EXPLAINED AWAY, and the cause is not the engine:

* reproducing the OLD runner's exact read + compute for one symbol matches the
  frozen panel EXACTLY (1210 cells, max |diff| 0.000e+00) — the baseline is
  reproducible and the comparison target is right;
* the same symbol under the new CLOSE view differs in 19 of 1210 cells (the warm-up
  difference that WAS expected); under the DECISION view, all 1210 differ;
* so the whole difference is the 14:50 truncation the decision view applies — and
  compute_jump_amount_corr is the ONLY one of the eleven with no decision-time
  truncation of its own (zero decision_time / prepare_visible_minute_bars references
  in its module; the other ten have 4-10 each), so the old runners handed it
  09:30-15:00 of day d.

THE DECISIVE TEST, now committed. Perturb ONLY the bars strictly after the cutoff,
assert every pre-cutoff row byte-identical, ask whether the day-d value moves. On
the real cache (12 CSI500 names, 2021-07..2021-12, 361,500 bars, 4.6% post-cutoff):
nine factors moved 0 cells at max |diff| 0.000e+00; jump_amount_corr_20 moved
1,477 of 1,477 at max |diff| 1.276. The committed test reproduces the same split on
synthetic bars with a realistic 09:31-11:30 / 13:01-15:00 session (a session ending
before 14:50 would make the perturbation a no-op — refused by a pre-assertion).

WHAT IT MEANS, stated and not fixed. Under exec_to_exec — the only basis the D5/D7
contract keeps — the entry anchor for date d is d's 14:51 execution bar, so a value
built from d's 14:50-15:00 bars uses information from after its own entry. PR #79's
merge-time self-check asserted the opposite in general ("the factor is known at
14:50"); for this one factor that is false, and #79's review never returned. Its
exec report also DECLARES decision_cutoff=14:50 (via intraday_spec_variant), which
its values do not honour. On close_to_close, entry is close(d) and using day d is
the conventional, already-declared-optimistic boundary, not a new defect.

Flagged, not repaired, per the D5a precedent for found defects: truncating it would
change a published factor's values and could move its verdict — a research decision
with a pre-registered hypothesis attached, not a refactor's business (§〇). The
exception is asserted POSITIVELY, so a later "fix" turns the test red and forces the
call to be made deliberately rather than noticed afterwards.

CONSEQUENCE FOR C5 the plan did not anticipate: for this factor the frozen D1 panel
and the new decision-view engine differ wholesale, and the correct engine is the NEW
one. The fourth leg's "relative <= 1e-12" cannot be the pass condition here; the
attribution is "the baseline had no 14:50 truncation for this factor", and making
the new engine reproduce the baseline would be reproducing the leak.

…o runs, two claims

Review APPROVE-WITH-NITS follow-up: MEDIUM-1, MEDIUM-2, LOW-1.

MEDIUM-1 — the test that claimed to pin cc06d32 could not.
It matched SUBSTRINGS in the function's source
(`"replace(" in source and "EXEC_TO_EXEC" in source and "DECISION" in source`).
Review broke it by hand: gut the assignment to a bare `replace(eval_cfg)`, leave the
two tokens in a COMMENT — the exec path then inherits the caller's CLOSE identity and
every exec artifact declares `view=close/close_to_close` while being scored on exec
returns. 18 tests in the file passed; 52 across the three files that import
`exec_basis_eval` passed. #78's rule again (a lexical assertion cannot hold a
semantic claim), failing in the worst direction: it waved through exactly the defect
the commit under test had just fixed. It also had a false-positive direction —
refactoring that line into a helper deletes the tokens and reddens a correct build.

The identity restatement is now the extracted `exec_identity()` and the claim is
BEHAVIOURAL: close-default config in, `view=decision` / `return_basis=exec_to_exec`
out, and every other field bit-identical.

MEDIUM-2 — the exec path declared `view=decision` unconditionally, and on two
classes of run that sentence was false. `view` is defined as "the information set
the FACTOR VALUES were taken under", but a with-book run has TWO information sets:
the subject factor's and the book's (value_ep / value_bp / volatility_20 take
close(d) and the evening daily_basic(d) — design §1.1's live defect, open until D7).
One field silently reported the clean one. That is the "report declares a check it
did not do" failure this field exists to prevent, one level up. Free to fix now
because no artifact carries it yet; after C5/C6 it would be baked into 22 files.

Chose the coordinator's (1)+(2): derive what can be derived, register what cannot.

  * `EvalConfig.book_view` (None = no book) — the book's view, declared by the ONLY
    party that knows it, the caller. `run_exec_basis_evaluation(book_view="close")`
    defaults to what every current caller actually does (the J4 rule: a default must
    be true for the callers that omit it). The no-book and with-book runs now get
    SEPARATE configs, so neither has to speak for the other. Deliberately NOT
    pairing-checked against the basis: a close-view book under an exec basis IS the
    disclosure, and refusing it would not un-mix the information sets, only stop the
    artifact from saying they are mixed.
  * `subject_view()` derives the SUBJECT's view from a measured fact —
    `factors.compute.minute.binding.NOT_DECISION_CUTOFF_SAFE`, a deny list of
    factors whose compute applies no 14:50 truncation. It lives with the factors
    (it is a fact about values, not about the eval path) and
    tests/test_decision_cutoff_visibility.py MEASURES it; the test's local copy of
    the name is gone, because two copies are two things to keep in step and the
    failure mode of drifting apart is an artifact declaring an information set its
    values do not have.
  * Consequence, intended and loud: `jump_amount_corr_20` yields
    (close, exec_to_exec), which `EvalConfig` refuses. Correct — until that factor
    is truncated there IS no honest exec artifact of it, and a blocked run beats a
    false one (red line #9). The generic pairing message is re-raised with the
    specific reason so nobody hunts for a config typo. The separate correctness-fix
    PR clears it by dropping one entry from the deny list.

LOW-1 — `test_identity_phrase_is_authored_once` asserted the phrase's FORMAT, not
that no second place spells it. The property does hold (one producer, three call
sites) but a name must not claim more than its assertions: renamed to
`test_identity_phrase_covers_both_pairings_and_states_the_book`.

A GAP I FOUND IN MY OWN NEW TESTS, and closed. Unit-testing `exec_identity` says
nothing about how the caller WIRES it: passing `book_view=None` for the with-book run
— a book was supplied, the report says there was none — passed all 28 tests. The
end-to-end assertion now lives in tests/test_exec_basis_eval.py, reads both written
JSONs, and checks the rendered Markdown says it too. Same shape as MEDIUM-1, one
level down; recorded rather than quietly patched.

Mutation evidence (every mutation first asserted to change its target):
  A  gut `exec_identity` to `replace(eval_cfg)` (the review's own escape)
     -> 3 FAIL (was: 52 pass)                                    rc=1 -> restored pass
  B  with-book run gets `book_view=None`
     -> pre-check: 28 passed (the gap, proven before fixing);
        after adding the wiring test -> 1 FAIL `assert None == 'close'`  rc=1 -> pass
  C  empty `NOT_DECISION_CUTOFF_SAFE`
     -> 3 FAIL, incl. the MEASUREMENT test finding jump dirty     rc=1 -> restored pass
  D  `subject_view` back to a hard-coded `View.DECISION`
     -> 1 FAIL                                                   rc=1 -> restored pass

Catalogue §七之二 updated BEFORE any artifact regenerates: `eval_config` is +3 keys
(not +2), the no_book/with_book blocks now legitimately differ in `book_view`, and
the jump_amount_corr exec block is registered as an intended loud refusal.

Gates: pytest 2228 passed / ruff clean / 31 configs / phase0 ic 0.9600 annual 0.8408
unchanged / provisional anchors green / exec baseline --verify 77/77 at 45c14aa /
frozen panel mtimes untouched.